package com.company.dcm.utils;


import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;

public class BinHexUtil {
    /**
     * 16进制转10进制
     * @param bytes
     * @param start 起始位置
     * @param end 终止位的后一位
     * @return
     */
    public static Long byteArrayToLong(byte[] bytes, int start, int end) {
        Long value = 0L;
        for (int i = start; i < end; i++) {
            // 将 byte 值转换为无符号的整数
            int unsignedByte = bytes[i] & 0xFF;
            // 将无符号整数左移相应的位数,并累加到 value 中
            value = (value << 8) + unsignedByte;
        }
        return value;
    }

    /**
     * 将 4 字节的 Unix 时间戳转换为日期时间字符串
     * @param bytes 4 字节的字节数组
     * @param byteOrder 字节序（BIG_ENDIAN 或 LITTLE_ENDIAN）
     * @return 格式化的日期时间字符串（如 "2023-10-01 12:34:56"）
     */
    public static Date decodeUnixTimestamp(byte[] bytes,ByteOrder byteOrder) {
        // 验证字节长度
        if (bytes.length != 4) {
            throw new IllegalArgumentException("字节数组长度必须为4");
        }

        // 将字节转换为 int（处理字节序）
        int timestamp = ByteBuffer.wrap(bytes)
                .order(byteOrder)
                .getInt();

        // 处理无符号整数（解决 2038 年问题）
        long epochSeconds = Integer.toUnsignedLong(timestamp);

        // 转换为 Instant（精确到秒）
        Instant instant = Instant.ofEpochSecond(epochSeconds);

        // 转换为本地时间（或保持 UTC）
        Date dateTime = Date.from(instant);

        return dateTime;
    }

    public static int byteArrayToInt(byte[] bytes, int start, int end) {
        int value = 0;
        for (int i = start; i <end; i++) {
            // 将 byte 值转换为无符号的整数
            int unsignedByte = bytes[i] & 0xFF;
            // 将无符号整数左移相应的位数,并累加到 value 中
            value = (value << 8) + unsignedByte;
        }
        return value;
    }

    /**
     * 十六进制字符串转换为字节数组
     * @param hexString
     * @return
     */
    public static byte[] hexStringToByteArray(String hexString) {
        hexString = hexString.replaceAll(" ", "");
        int len = hexString.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个字节
            bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
                    .digit(hexString.charAt(i+1), 16));
        }
        return bytes;
    }

    /**
     * 字节数组转换为ascii字符串
     * @param bytes
     * @return
     */
    public static String byteArrayToAsciiString(byte[] bytes,int start,int end){
        StringBuilder sb = new StringBuilder();
        for (int i=start;i<end;i++) {
            if(bytes[i]==0)sb.append('0');
            else sb.append((char)(bytes[i] & 0xff));

        }
        return sb.toString();
    }

    /**
     * 将十进制字符串(0-65535)转换为4字节十六进制字符串，其中低位2字节在前，高位2字节在后
     * 例：2 -> 0200
     * @param decString
     * @return
     */
    public static String decStringToHexString(String decString){
        StringBuilder sb = new StringBuilder();
        sb.append(Integer.toHexString(Integer.valueOf(decString)));

        while(sb.length() < 4){
            sb.insert(0, 0);
        }

        String hexString = sb.substring(2, 4);
        hexString += sb.substring(0, 2);

        return hexString;
    }

    /**
     * 将4字节十六进制字符串转换为十进制字符串
     * 例：0200 -> 2
     * @param hexString
     * @return
     */
    public static String hexStringToDecString(String hexString){
        String low = hexString.substring(2, 4);
        String high = hexString.substring(0, 2);
        return Integer.valueOf(low + high, 16).toString();
    }
}
